import axios from 'axios';
const API_BASE_URL = 'http://localhost:8000/api/v1';

const service = axios.create({
  baseURL: API_BASE_URL,
  timeout: 15000 // 超时时间设置为15秒，确保有足够时间等待后端响应
});

// 重试配置
const RETRY_COUNT = 3; // 增加到3次重试
const RETRY_DELAY = 1000; // 初始重试延迟1秒
const MAX_TIMEOUT = 30000; // 增加最大超时时间到30秒
const BACKOFF_FACTOR = 1.5; // 指数退避因子

// 请求拦截器：自动添加API-Key鉴权
service.interceptors.request.use(
  (config) => {
    const apiKey = localStorage.getItem('maess_api_key');
    if (apiKey) config.headers['API-Key'] = apiKey;
    
    // 初始化重试计数
    config.retry = config.retry || 0;
    config.retryDelay = config.retryDelay || RETRY_DELAY;
    
    return config;
  },
  (error) => Promise.reject(error)
);

// 响应拦截器：处理各种错误情况
service.interceptors.response.use(
  (response) => response.data,
  (error) => {
    // 获取请求配置
    const config = error.config || {};
    
    if (error.response?.status === 401) {
      localStorage.removeItem('maess_api_key');
      window.location.reload();
    } else if (error.code === 'ECONNABORTED') {
      const timeoutMessage = `请求超时: ${new Date().toISOString()}`;
      console.error(timeoutMessage, 'URL:', config.url);
      
      // 实现重试逻辑
      if (config.retry < RETRY_COUNT && !config._retry) {
        // 计算指数退避延迟时间，添加随机抖动避免雪崩
        const retryNumber = config.retry + 1;
        const baseDelay = config.retryDelay * Math.pow(BACKOFF_FACTOR, retryNumber - 1);
        const jitter = Math.random() * 0.3; // 添加30%的随机抖动
        const actualDelay = baseDelay * (1 + jitter);
        
        console.log(`正在尝试重试请求 (${retryNumber}/${RETRY_COUNT})...`);
        console.log(`重试延迟: ${Math.round(actualDelay)}ms, 当前超时: ${config.timeout}ms`);
        
        config._retry = true;
        config.retry += 1;
        // 动态增加超时时间，每次增加更多
        config.timeout = Math.min(config.timeout + (3000 * retryNumber), MAX_TIMEOUT);
        
        // 延迟重试，使用计算出的退避时间
        return new Promise(resolve => {
          setTimeout(() => {
            // 在重试前检查网络状态
            if (navigator && navigator.onLine === false) {
              console.warn('检测到离线状态，延迟重试');
              setTimeout(() => resolve(service(config)), 5000); // 离线状态下延迟5秒后重试
            } else {
              resolve(service(config));
            }
          }, actualDelay);
        });
      }
      
      // 增强的超时错误处理
      const enhancedError = new Error('加载超时，请检查网络连接。已尝试多次重试。');
      enhancedError.code = 'ECONNABORTED';
      enhancedError.originalError = error;
      enhancedError.timestamp = new Date().toISOString();
      enhancedError.retriesAttempted = config.retry || 0;
      return Promise.reject(enhancedError);
    } else if (!error.response) {
      // 处理网络错误 (无响应)
      const networkError = new Error('网络连接失败，请检查网络设置');
      networkError.originalError = error;
      networkError.timestamp = new Date().toISOString();
      return Promise.reject(networkError);
    }
    return Promise.reject(error);
  }
);

// 核心接口
export const api = {
  login: (apiKey) => {
    localStorage.setItem('maess_api_key', apiKey);
    return service.get('/status');
  },
  logout: () => localStorage.removeItem('maess_api_key'),
  search: (data) => service.post('/search', data),
  getStatus: () => service.get('/status')
};

export default service;